const express = require('express');
const app = express();
// 添加 express.json() 中间件来解析 JSON 请求体
const port = 38128;
const fs = require('fs');
const path = require('path');
const jsonFilePath = path.resolve(__dirname, 'data.json');
const verifyToken = require('./isToken.js');

app.use(express.json()); // 使用 JSON 解析中间件


const jwt = require('jsonwebtoken');

// 密钥，用于生成和验证 token
const secretKey = 'test';
// 读取 JSON 文件并挂载到全局对象中
try {
  const jsonData = fs.readFileSync(jsonFilePath, 'utf8');
  const parsedData = JSON.parse(jsonData);

  // 遍历 JSON 文件中的每个列表，并将其挂载到全局对象中
  for (const key in parsedData) {
    if (parsedData.hasOwnProperty(key)) {
      global[key] = parsedData[key];
      console.log(`列表 ${key} 已成功挂载到全局对象中。`);
    }
  }
} catch (err) {
  console.error('读取或解析 JSON 文件时出错：', err);
}
app.post('/login', (req, res) => {
  console.log(req)
  const userName = req.body.userName
  const passWord = req.body.passWord
  const userId = ''
  // 假设登录验证成功后获取到的用户信息
  const user = {}
  // 生成 token
  if (!userName || userName == '') {
    res.json({
      code: 403,
      msg: '请输入账号'
    });
  }

  fs.readFile(jsonFilePath, 'utf-8', (err, fileData) => {
    if (err) {
      console.error('读取文件时出错:', err);
      res.json({
        code: 403,
        msg: '读取文件时出错'
      });
      return;
    }
    let isLogin = false
    let isPassWord = false
    // 解析 JSON 数据
    let jsonData = JSON.parse(fileData);

    for (let i = 0; i < jsonData.userList.length; i++) {
      if (userName === jsonData.userList[i].userName) {
        isLogin = true
        if (passWord === jsonData.userList[i].passWord) {
          isPassWord = true
          user.userId = jsonData.userList[i].userId
          user.userName = jsonData.userList[i].userName
        }
      }
    }
    const token = jwt.sign(user, secretKey, {
      expiresIn: '24h'
    });
    user.token = token
    const tikenStr = ''

    // 使用 verify 方法解析 Token
    if (token) {
      jwt.verify(token, secretKey, (error, decoded) => {
        if (error) {
          console.error('Token decoding failed:', error.message);
        } else {
          console.log('Decoded token:', decoded);
          // 在 decoded 中可以获取到 Token 中存储的信息
        }
      });
    }
    console.log(userName, passWord)
    if (isLogin, isPassWord) {
      res.json({
        code: 200,
        userInfo: user,
        msg: '登录成功！'
      });
    }
    if (!isLogin) {
      res.json({
        code: 403,
        msg: '用户不存在！'
      });
    }
    if (isLogin, !isPassWord) {
      res.json({
        code: 403,
        msg: '密码错误！'
      });
    }

  });
  // 返回分页结果
})
//注册
app.post('/register', (req, res) => {
  const userInfo = req.body;
  fs.readFile(jsonFilePath, 'utf-8', (err, fileData) => {
    if (err) {
      console.error('读取文件时出错:', err);
      res.json({
        code: 403,
        msg: '读取文件时出错'
      });
      return;
    }

    // 解析 JSON 数据
    let jsonData = JSON.parse(fileData);
    for (let i = 0; i < jsonData.userList.length; i++) {
      if (jsonData.userList[i].userName == userInfo.userName) {
        res.json({
          code: 403,
          msg: '该用户名已被注册'
        });
        return false
      }
    }
    jsonData.userList.push({
      "userId": jsonData.userList.length + 1,
      "userName": userInfo.userName,
      "passWord": userInfo.passWord
    }, );

    // 将更新后的数据转换回 JSON 字符串
    const updatedData = JSON.stringify(jsonData, null, 2);

    // 将更新后的数据保存到文件中
    fs.writeFile(jsonFilePath, updatedData, 'utf-8', (err) => {
      if (err) {
        console.error('写入文件时出错:', err);
        res.json({
          code: 403,
          msg: '写入文件时出错'
        });
        return;
      }
      console.log('用户信息已成功添加到 data.json 文件中');
      res.json({
        code: 200,
        msg: '用户注册成功'
      });
    });
  });
});
// 定义分页列表接口
app.post('/nodeApi/list', verifyToken, (req, res) => {
  // 获取分页参数，默认第一页，每页显示 10 条
  const current = parseInt(req.body.current) || 1;
  const size = parseInt(req.body.size) || 10;

  // 计算数据的起始索引和结束索引
  const startIndex = (current - 1) * size;
  const endIndex = current * size;

  // 获取当前页的数据
  const currentPageData = global.data.slice(startIndex, endIndex);

  // 构造分页结果对象
  const pagination = {
    code: 200,
    data: {
      page: {
        current: current,
        size: size,
        total: global.data.length,
        totalPage: Math.ceil(global.data.length / size),
      },
      list: currentPageData
    }
  };

  // 返回分页结果
  res.json(pagination);
});

const WebSocket = require('ws');

// 创建 WebSocket 服务器
const wss = new WebSocket.Server({
  port: 46210
});
// 定义存储连接的客户端的数组
const clients = [];

// 监听连接事件
wss.on('connection', function connection(ws) {

  // 将新连接的客户端添加到数组中
  clients.push(ws);

  // 监听消息事件
  ws.on('message', function incoming(messageText) {

    // 循环遍历所有客户端，将收到的消息发送给每个客户端
    clients.forEach(client => {
      const obj = JSON.parse(messageText.toString())
      const newObj = {}
      if (obj.type == 'up') {
        client.send(JSON.stringify({
          name: obj.name,
          userId: obj.userId,
          msg: obj.msg,
          type: obj.type,
        }));
      }
      if (client !== ws && client.readyState === WebSocket.OPEN) {
        newObj.name = obj.name
        newObj.userId = obj.userId
        newObj.msg = obj.msg
        newObj.type = obj.type
        newObj.time = obj.time
        console.log(obj.msg)
        if ((newObj.msg || newObj.msg != '') && obj.type == 'msg') {
          client.send(JSON.stringify(newObj));
        }
      }
    });
  });

  // 监听断开事件
  ws.on('close', function close() {

    // 当有客户端断开连接时，从数组中移除对应的客户端
    clients.splice(clients.indexOf(ws), 1);
  });
});

// const server = app.listen(0, function () {
//   const host = server.address().address;
//   const port = server.address().port;
//   console.log('App listening at http://%s:%s', host, port);
// });
app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}/`);
});